const express = require('express');
const fs = require('fs').promises;
const path = require('path');
const cors = require('cors');

const app = express();
const PORT = process.env.PORT || 3000;

// 数据文件路径
const DATA_FILE = path.join(__dirname, 'data', 'risk_data.json');
const MESSAGES_FILE = path.join(__dirname, 'data', 'messages.json');

// 中间件
app.use(cors());
app.use(express.json({ limit: '50mb' }));
app.use(express.static('public')); // 静态文件服务，用于托管HTML文件

// 确保数据目录存在
async function ensureDataDirectory() {
    const dataDir = path.join(__dirname, 'data');
    try {
        await fs.access(dataDir);
    } catch (error) {
        if (error.code === 'ENOENT') {
            await fs.mkdir(dataDir, { recursive: true });
            console.log('已创建数据目录');
        }
    }
}

// 读取JSON文件
async function readJsonFile(filePath) {
    try {
        const data = await fs.readFile(filePath, 'utf8');
        return JSON.parse(data);
    } catch (error) {
        if (error.code === 'ENOENT') {
            return null; // 文件不存在
        }
        throw error;
    }
}

// 写入JSON文件
async function writeJsonFile(filePath, data) {
    await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf8');
}

// API路由

// 获取风险数据
app.get('/api/data', async (req, res) => {
    try {
        const data = await readJsonFile(DATA_FILE);
        if (!data) {
            return res.status(404).json({ error: '没有找到数据文件' });
        }
        res.json(data);
    } catch (error) {
        console.error('读取数据文件失败:', error);
        res.status(500).json({ error: '读取数据失败' });
    }
});

// 保存风险数据
app.post('/api/data', async (req, res) => {
    try {
        const data = req.body;
        
        // 验证数据结构
        if (!data || typeof data !== 'object') {
            return res.status(400).json({ error: '无效的数据格式' });
        }
        
        // 添加服务器端时间戳
        data.serverTimestamp = new Date().getTime();
        data.serverUpdateDate = new Date().toLocaleString('zh-CN', {
            timeZone: 'Asia/Shanghai'
        });
        
        await writeJsonFile(DATA_FILE, data);
        console.log('数据已保存:', new Date().toLocaleString());
        
        res.json({ 
            success: true, 
            message: '数据保存成功',
            timestamp: data.serverTimestamp 
        });
    } catch (error) {
        console.error('保存数据失败:', error);
        res.status(500).json({ error: '保存数据失败' });
    }
});

// 删除风险数据
app.delete('/api/data', async (req, res) => {
    try {
        // 检查文件是否存在
        try {
            await fs.access(DATA_FILE);
            await fs.unlink(DATA_FILE);
            console.log('数据文件已删除');
        } catch (error) {
            if (error.code !== 'ENOENT') {
                throw error;
            }
            // 文件不存在，也算成功
        }
        
        res.json({ success: true, message: '数据已清除' });
    } catch (error) {
        console.error('删除数据失败:', error);
        res.status(500).json({ error: '删除数据失败' });
    }
});

// 获取留言
app.get('/api/messages', async (req, res) => {
    try {
        const messages = await readJsonFile(MESSAGES_FILE);
        if (!messages) {
            return res.json([]); // 返回空数组而不是404
        }
        res.json(messages);
    } catch (error) {
        console.error('读取留言失败:', error);
        res.status(500).json({ error: '读取留言失败' });
    }
});

// 添加留言
app.post('/api/messages', async (req, res) => {
    try {
        const newMessage = req.body;
        
        // 验证留言数据
        if (!newMessage || !newMessage.author || !newMessage.position || !newMessage.content) {
            return res.status(400).json({ error: '留言数据不完整' });
        }
        
        // 添加服务器端时间戳
        newMessage.serverTimestamp = new Date().getTime();
        
        // 读取现有留言
        let messages = await readJsonFile(MESSAGES_FILE) || [];
        
        // 添加新留言
        messages.push(newMessage);
        
        // 限制留言数量（可选，防止文件过大）
        const MAX_MESSAGES = 1000;
        if (messages.length > MAX_MESSAGES) {
            messages = messages.slice(-MAX_MESSAGES); // 保留最新的1000条
        }
        
        // 保存留言
        await writeJsonFile(MESSAGES_FILE, messages);
        
        console.log('新留言已保存:', newMessage.author, '-', newMessage.content.substring(0, 50));
        
        res.json({ 
            success: true, 
            message: '留言保存成功',
            timestamp: newMessage.serverTimestamp 
        });
    } catch (error) {
        console.error('保存留言失败:', error);
        res.status(500).json({ error: '保存留言失败' });
    }
});

// 清除所有留言
app.delete('/api/messages', async (req, res) => {
    try {
        // 检查文件是否存在
        try {
            await fs.access(MESSAGES_FILE);
            await fs.unlink(MESSAGES_FILE);
            console.log('留言文件已删除');
        } catch (error) {
            if (error.code !== 'ENOENT') {
                throw error;
            }
            // 文件不存在，也算成功
        }
        
        res.json({ success: true, message: '留言已清空' });
    } catch (error) {
        console.error('清除留言失败:', error);
        res.status(500).json({ error: '清除留言失败' });
    }
});

// 健康检查接口
app.get('/api/health', (req, res) => {
    res.json({ 
        status: 'ok', 
        timestamp: new Date().getTime(),
        message: 'AOC风险管理系统API运行正常' 
    });
});

// 获取系统信息
app.get('/api/info', async (req, res) => {
    try {
        const dataExists = await readJsonFile(DATA_FILE) !== null;
        const messages = await readJsonFile(MESSAGES_FILE) || [];
        
        res.json({
            hasData: dataExists,
            messageCount: messages.length,
            serverTime: new Date().toLocaleString('zh-CN', {
                timeZone: 'Asia/Shanghai'
            })
        });
    } catch (error) {
        console.error('获取系统信息失败:', error);
        res.status(500).json({ error: '获取系统信息失败' });
    }
});

// 错误处理中间件
app.use((error, req, res, next) => {
    console.error('服务器错误:', error);
    res.status(500).json({ error: '服务器内部错误' });
});

// 404处理
app.use((req, res) => {
    res.status(404).json({ error: '接口不存在' });
});

// 启动服务器
async function startServer() {
    try {
        await ensureDataDirectory();
        
        app.listen(PORT, () => {
            console.log('=================================');
            console.log(`AOC风险管理系统API服务器已启动`);
            console.log(`服务器地址: http://localhost:${PORT}`);
            console.log(`API接口: http://localhost:${PORT}/api/`);
            console.log(`数据文件: ${DATA_FILE}`);
            console.log(`留言文件: ${MESSAGES_FILE}`);
            console.log('=================================');
        });
    } catch (error) {
        console.error('启动服务器失败:', error);
        process.exit(1);
    }
}

// 优雅关闭
process.on('SIGINT', () => {
    console.log('\n正在关闭服务器...');
    process.exit(0);
});

process.on('SIGTERM', () => {
    console.log('\n正在关闭服务器...');
    process.exit(0);
});

// 启动服务器
startServer();